home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / pvm34b3.zip / pvm34b3 / pvm3 / src / lpvmpack.c < prev    next >
C/C++ Source or Header  |  1997-07-22  |  45KB  |  2,327 lines
  1.  
  2. static char rcsid[] =
  3.     "$Id: lpvmpack.c,v 1.10 1997/06/27 17:32:29 pvmsrc Exp $";
  4.  
  5. /*
  6.  *         PVM version 3.4:  Parallel Virtual Machine System
  7.  *               University of Tennessee, Knoxville TN.
  8.  *           Oak Ridge National Laboratory, Oak Ridge TN.
  9.  *                   Emory University, Atlanta GA.
  10.  *      Authors:  J. J. Dongarra, G. E. Fagg, M. Fischer
  11.  *          G. A. Geist, J. A. Kohl, R. J. Manchek, P. Mucci,
  12.  *         P. M. Papadopoulos, S. L. Scott, and V. S. Sunderam
  13.  *                   (C) 1997 All Rights Reserved
  14.  *
  15.  *                              NOTICE
  16.  *
  17.  * Permission to use, copy, modify, and distribute this software and
  18.  * its documentation for any purpose and without fee is hereby granted
  19.  * provided that the above copyright notice appear in all copies and
  20.  * that both the copyright notice and this permission notice appear in
  21.  * supporting documentation.
  22.  *
  23.  * Neither the Institutions (Emory University, Oak Ridge National
  24.  * Laboratory, and University of Tennessee) nor the Authors make any
  25.  * representations about the suitability of this software for any
  26.  * purpose.  This software is provided ``as is'' without express or
  27.  * implied warranty.
  28.  *
  29.  * PVM version 3 was funded in part by the U.S. Department of Energy,
  30.  * the National Science Foundation and the State of Tennessee.
  31.  */
  32.  
  33. /*
  34.  *    lpvmpack.c
  35.  *
  36.  *    Typed packing/unpacking, message buffer manip.
  37.  *
  38. $Log: lpvmpack.c,v $
  39.  * Revision 1.10  1997/06/27  17:32:29  pvmsrc
  40.  * Updated for WIN32 header files & Authors.
  41.  *
  42.  * Revision 1.9  1997/05/07  21:23:29  pvmsrc
  43.  * Added new pvmupkstralloc() for dynamic string unpacking lunacy.
  44.  *     - with proto in header.
  45.  *
  46.  * Revision 1.8  1997/05/01  20:05:30  pvmsrc
  47.  * Made pvmmidh and pvmmidhsiz global so that lpvmshmem can see them..... [GEF]
  48.  *
  49.  * Revision 1.7  1997/05/01  14:11:48  pvmsrc
  50.  * SGI Compiler Warning Cleanup.
  51.  *
  52.  * Revision 1.6  1997/01/28  19:26:50  pvmsrc
  53.  * New Copyright Notice & Authors.
  54.  *
  55.  * Revision 1.5  1996/10/25  13:57:29  pvmsrc
  56.  * Replaced old #includes for protocol headers:
  57.  *     - <pvmsdpro.h>, "ddpro.h", "tdpro.h"
  58.  * With #include of new combined header:
  59.  *     - <pvmproto.h>
  60.  *
  61.  * Revision 1.4  1996/10/24  22:25:59  pvmsrc
  62.  * Moved #include "global.h" below other #include's for typing.
  63.  * Added #include of new "lpvm.h" header to replace explicit externs.
  64.  * Modified trace event generation for message / packing routines:
  65.  *     - replaced old TEV_*[01] constants with new TEV_EVENT_ENTRY/EXIT.
  66.  *     - replaced standard pvm_pk*() calls with new TEV_PACK_*() macro
  67.  *         calls and TEV_DID_* identification.
  68.  *     - in pvm_pkstr(), don't pack string length for user-defined packing
  69.  *         (PvmDataTrace encoding).
  70.  *
  71.  * Revision 1.3  1996/10/23  15:57:25  pvmsrc
  72.  * Changed pvm_freebuf so that freeing the null buffer '0' nolonger causes
  73.  * an error message. Many old 3.3 codes showed this through the use of
  74.  * pvm_freebuf(pvm_setsbuf(x)) etc where there was no old send buffer and
  75.  * hense under 3.4 an error was caused.
  76.  *
  77.  * This saves having to change BLACS, ParckBench and some collective
  78.  * Group operations.
  79.  *
  80.  * When freeing buffer 0, PvmOK is returned.
  81.  *
  82.  * Revision 1.2  1996/09/23  23:28:55  pvmsrc
  83.  * Initial Creation - original lpvmpack.c.
  84.  *
  85.  * Revision 1.12  1995/11/02  16:13:16  manchek
  86.  * added NEEDSENDIAN switch
  87.  *
  88.  * Revision 1.11  1995/09/05  19:17:03  manchek
  89.  * fp sometimes wasn't set in enc_xdr_init.
  90.  * overflow test was wrong in enc_xdr_long
  91.  *
  92.  * Revision 1.10  1995/07/28  16:04:06  manchek
  93.  * switch endian includes on flag, not arch name
  94.  *
  95.  * Revision 1.9  1995/07/19  20:15:45  manchek
  96.  * enc*init should append a frag to message if there's already one
  97.  *
  98.  * Revision 1.8  1995/06/27  21:51:13  manchek
  99.  * update fr_num_unpacked before pre_bcopy in byteupk
  100.  *
  101.  * Revision 1.7  1995/05/17  16:19:34  manchek
  102.  * added support for CSPP shared memory
  103.  *
  104.  * Revision 1.6  1995/02/01  21:22:27  manchek
  105.  * new function enc_xdr_ulong.
  106.  * added overflow tests to enc_xdr_long, enc_xdr_ulong, return PvmOverflow
  107.  *
  108.  * Revision 1.5  1994/11/09  15:01:58  manchek
  109.  * pvm_pkstr and pvm_packf(%s) must fail with PvmNotImpl if PvmDataInPlace
  110.  * is used.
  111.  *
  112.  * Revision 1.4  1994/06/03  21:15:12  manchek
  113.  * oops, missed a bcopy
  114.  *
  115.  * Revision 1.3  1994/06/03  20:38:17  manchek
  116.  * version 3.3.0
  117.  *
  118.  * Revision 1.2  1993/10/04  19:20:22  manchek
  119.  * fixed vpackf() - floats get passed as doubles, must unpack that way
  120.  *
  121.  * Revision 1.1  1993/08/30  23:26:48  manchek
  122.  * Initial revision
  123.  *
  124.  */
  125. #ifdef WIN32
  126. #include "pvmwin.h"
  127. #endif
  128. #include <stdio.h>
  129. #ifdef NEEDMENDIAN
  130. #include <machine/endian.h>
  131. #endif
  132. #ifdef NEEDENDIAN
  133. #include <endian.h>
  134. #endif
  135. #ifdef NEEDSENDIAN
  136. #include <sys/endian.h>
  137. #endif
  138. #ifndef WIN32
  139. #include <rpc/types.h>
  140. #include <rpc/xdr.h>
  141. #else
  142. #include "..\xdr\types.h"
  143. #include "..\xdr\xdr.h"
  144. #endif
  145. #include <ctype.h>
  146. #ifdef    __STDC__
  147. #include <stdarg.h>
  148. #else
  149. #include <varargs.h>
  150. #endif
  151. #include <pvm3.h>
  152. #include <pvmproto.h>
  153. #include <pvmtev.h>
  154. #include "pvmalloc.h"
  155. #include "pvmfrag.h"
  156. #include "pmsg.h"
  157. #include "listmac.h"
  158. #include "bfunc.h"
  159. #include "lpvm.h"
  160. #include "tevmac.h"
  161. #include "global.h"
  162.  
  163. /* message heap element */
  164.  
  165. struct mhp {
  166.     int m_free;                    /* free list (next or 0) */
  167.     struct pmsg *m_umb;            /* message or null if on free list */
  168. };
  169.  
  170.  
  171. /***************
  172.  **  Globals  **
  173.  **           **
  174.  ***************/
  175.  
  176. /* XXX these moved here from Private list so lpvmshmem can find them */
  177. struct mhp *pvmmidh = 0;            /* heap of all msgs */
  178. int pvmmidhsiz = 0;                /* length of pvmmidh */
  179.  
  180. /***************
  181.  **  Private  **
  182.  **           **
  183.  ***************/
  184.  
  185. static int pvmmidhfree = 0;                /* head of midh free list */
  186.  
  187.  
  188. /***********************************************
  189.  **  Umbuf (pmsg wrapper with mid) Functions  **
  190.  **                                           **
  191.  ***********************************************/
  192.  
  193.  
  194. /*    mid_new()
  195. *
  196. *    Allocate a message id for a new message.
  197. *    Returns mid (>0), or PvmNoMem if can't get memory.
  198. */
  199.  
  200. static int
  201. mid_new(mp)
  202.     struct pmsg *mp;
  203. {
  204.     static int nxtmidhsiz;
  205.     int mid;
  206.     int ns;
  207.     struct mhp *newh;
  208.  
  209.     /* check free list empty */
  210.  
  211.     if (!pvmmidhfree) {
  212.  
  213.     /* extend midh array */
  214.  
  215.         if (pvmmidhsiz) {
  216.             ns = nxtmidhsiz;
  217.             if (!(newh = TREALLOC(pvmmidh, ns, struct mhp)))
  218.                 return PvmNoMem;
  219.             nxtmidhsiz += pvmmidhsiz;
  220.  
  221.         } else {
  222.             nxtmidhsiz = 13;
  223.             ns = 8;
  224.             if (!(newh = TALLOC(ns, struct mhp, "mid")))
  225.                 return PvmNoMem;
  226.         }
  227.         pvmmidh = newh;
  228.  
  229.     /* put new entries on free list */
  230.  
  231.         while (pvmmidhsiz < ns) {
  232.             pvmmidh[pvmmidhsiz].m_umb = 0;
  233.             pvmmidh[pvmmidhsiz].m_free = pvmmidhfree;
  234.             pvmmidhfree = pvmmidhsiz++;
  235.         }
  236.     }
  237.  
  238.     /* take next from free list */
  239.  
  240.     mid = pvmmidhfree;
  241.     pvmmidhfree = pvmmidh[pvmmidhfree].m_free;
  242.  
  243.     pvmmidh[mid].m_umb = mp;
  244.     mp->m_mid = mid;
  245.     return mid;
  246. }
  247.  
  248.  
  249. /*    mid_free()
  250. *
  251. *    Return a message id to the free list.
  252. */
  253.  
  254. static void
  255. mid_free(mid)
  256.     int mid;
  257. {
  258.     if (mid <= 0 || mid >= pvmmidhsiz || !pvmmidh[mid].m_umb)
  259.         return;
  260.     pvmmidh[mid].m_umb = 0;
  261.     pvmmidh[mid].m_free = pvmmidhfree;
  262.     pvmmidhfree = mid;
  263. }
  264.  
  265.  
  266. /*    struct ()
  267. *
  268. *    Create a new empty umbuf.
  269. */
  270.  
  271. struct pmsg *
  272. umbuf_new()
  273. {
  274.     struct pmsg *mp;
  275.  
  276.     if (mp = pmsg_new(0)) {
  277.         if (mid_new(mp) < 0) {
  278.             pmsg_unref(mp);
  279.             mp = 0;
  280.         }
  281.     }
  282.     return mp;
  283. }
  284.  
  285.  
  286. /*    umbuf_free()
  287. *
  288. *    Free an umbuf
  289. */
  290.  
  291. int
  292. umbuf_free(mp)
  293.     struct pmsg *mp;
  294. {
  295.     mid_free(mp->m_mid);
  296.     mp->m_mid = 0;
  297.     pmsg_unref(mp);
  298.     return 0;
  299. }
  300.  
  301.  
  302. /*    midtobuf()
  303. *
  304. *    Return pointer to message buffer given int message id.
  305. */
  306.  
  307. struct pmsg *
  308. midtobuf(mid)
  309.     int mid;
  310. {
  311.     return ((mid > 0 && mid < pvmmidhsiz) ? pvmmidh[mid].m_umb : 0);
  312. }
  313.  
  314.  
  315. int
  316. umbuf_dump(mid, lvl)
  317.     int mid;
  318.     int lvl;    /* 0 - summary, 1 - frag lengths, 2 - frag data */
  319. {
  320.     struct pmsg *mp;
  321.     struct frag *fp;
  322.  
  323.     if (mid <= 0) {
  324.         pvmlogprintf("umbuf_dump() BadParam\n");
  325.         return PvmBadParam;
  326.     }
  327.     if (!(mp = midtobuf(mid))) {
  328.         pvmlogprintf("umbuf_dump() NoSuchBuf\n");
  329.         return PvmNoSuchBuf;
  330.     }
  331.  
  332.     mp = pvmmidh[mid].m_umb;
  333.     pmsg_dump(mp, lvl);
  334.     return 0;
  335. }
  336.  
  337.  
  338. int
  339. umbuf_list(lvl)
  340.     int lvl;
  341. {
  342.     int i;
  343.     struct pmsg *mp;
  344.     struct frag *fp;
  345.     int rlen;
  346.  
  347.     for (i = 1; i < pvmmidhsiz; i++)
  348.         if (mp = pvmmidh[i].m_umb)
  349.             umbuf_dump(i, lvl);
  350.     return 0;
  351. }
  352.  
  353.  
  354. /************************
  355.  **  Libpvm Functions  **
  356.  **                    **
  357.  ************************/
  358.  
  359.  
  360. int
  361. pvm_mkbuf(enc)
  362.     int enc;        /* data format */
  363. {
  364.     struct pmsg *mp;
  365.     struct frag *fp;
  366.     int cc = 0;
  367.     TEV_DECLS
  368.  
  369.     if (TEV_EXCLUSIVE) {
  370.         if (TEV_DO_TRACE(TEV_MKBUF,TEV_EVENT_ENTRY)) {
  371.             TEV_PACK_INT( TEV_DID_ME, TEV_DATA_SCALAR, &enc, 1, 1 );
  372.             TEV_FIN;
  373.         }
  374.     }
  375.  
  376.     switch (enc) {                                /* verify encoding */
  377.     case PvmDataDefault:
  378.         enc = 0x10000000;        /* XXX this just forces XDR */
  379.         break;
  380.  
  381.     case PvmDataRaw:
  382.         enc = pvmmydsig;
  383.         break;
  384.  
  385.     case PvmDataInPlace:
  386.         enc = 0x20000000;
  387.         break;
  388.  
  389.     case PvmDataTrace:
  390.         enc = 0x40000000;
  391.         break;
  392.  
  393.     default:
  394.         cc = PvmBadParam;
  395.     }
  396.  
  397.     if (!cc) {
  398.         if (mp = umbuf_new()) {
  399.             mp->m_src = pvmmytid;
  400.             pmsg_setenc(mp, enc);
  401.             cc = mp->m_mid;
  402.         } else
  403.             cc = PvmNoMem;
  404.     }
  405.  
  406.     if (TEV_AMEXCL) {
  407.         if (TEV_DO_TRACE(TEV_MKBUF,TEV_EVENT_EXIT)) {
  408.             TEV_PACK_INT( TEV_DID_MB, TEV_DATA_SCALAR, &cc, 1, 1 );
  409.             TEV_FIN;
  410.         }
  411.         TEV_ENDEXCL;
  412.     }
  413.  
  414.     if (cc < 0)
  415.         lpvmerr("pvm_mkbuf", cc);
  416.     return cc;
  417. }
  418.  
  419.  
  420. int
  421. pvm_freebuf(mid)
  422.     int mid;        /* message handle */
  423. {
  424.     int cc;
  425.     struct pmsg *mp;
  426.     TEV_DECLS
  427.  
  428.     if (TEV_EXCLUSIVE) {
  429.         if (TEV_DO_TRACE(TEV_FREEBUF,TEV_EVENT_ENTRY)) {
  430.             TEV_PACK_INT( TEV_DID_MB, TEV_DATA_SCALAR, &mid, 1, 1 );
  431.             TEV_FIN;
  432.         }
  433.     }
  434.  
  435.     if (mid < 0) {
  436.         cc = PvmBadParam;
  437.     } else if (mp = midtobuf(mid)) {
  438.         if (pvmsbuf == mp)
  439.             pvmsbuf = 0;
  440.         if (pvmrbuf == mp)
  441.             pvmrbuf = 0;
  442.         umbuf_free(mp);
  443.         cc = 0;
  444.     } else if (mid)
  445.         cc = PvmNoSuchBuf;
  446.     else
  447.         cc = PvmOk;    /* don't complain when freeing the null/0 buffer */
  448.                 /* many 3.3 codes switch and free without checking */
  449.  
  450.     if (TEV_AMEXCL) {
  451.         if (TEV_DO_TRACE(TEV_FREEBUF,TEV_EVENT_EXIT)) {
  452.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  453.             TEV_FIN;
  454.         }
  455.         TEV_ENDEXCL;
  456.     }
  457.  
  458.     if (cc < 0)
  459.         lpvmerr("pvm_freebuf", cc);
  460.     return cc;
  461. }
  462.  
  463.  
  464. int
  465. pvm_setsbuf(mid)
  466.     int mid;
  467. {
  468.     struct pmsg *mp = 0;
  469.     int cc = 0;
  470.     TEV_DECLS
  471.  
  472.     if (TEV_EXCLUSIVE) {
  473.         if (TEV_DO_TRACE(TEV_SETSBUF,TEV_EVENT_ENTRY)) {
  474.             TEV_PACK_INT( TEV_DID_MB, TEV_DATA_SCALAR, &mid, 1, 1 );
  475.             TEV_FIN;
  476.         }
  477.     }
  478.  
  479.     if (mid < 0) {
  480.         cc = PvmBadParam;
  481.     } else if (mid == 0) {
  482.         cc = pvmsbuf ? pvmsbuf->m_mid : 0;
  483.         pvmsbuf = 0;
  484.     } else if (mp = midtobuf(mid)) {
  485.         if (mp == pvmrbuf)
  486.             pvmrbuf = 0;
  487.         cc = pvmsbuf ? pvmsbuf->m_mid : 0;
  488.         pvmsbuf = mp;
  489.         (mp->m_codef->enc_init)(mp);
  490.     } else
  491.         cc = PvmNoSuchBuf;
  492.  
  493.     if (TEV_AMEXCL) {
  494.         if (TEV_DO_TRACE(TEV_SETSBUF,TEV_EVENT_EXIT)) {
  495.             TEV_PACK_INT( TEV_DID_MSB, TEV_DATA_SCALAR, &cc, 1, 1 );
  496.             TEV_FIN;
  497.         }
  498.         TEV_ENDEXCL;
  499.     }
  500.  
  501.     if (cc < 0)
  502.         lpvmerr("pvm_setsbuf", cc);
  503.     return cc;
  504. }
  505.  
  506.  
  507. int
  508. pvm_getsbuf()
  509. {
  510.     int cc;
  511.     TEV_DECLS
  512.  
  513.     if (TEV_EXCLUSIVE) {
  514.         if (TEV_DO_TRACE(TEV_GETSBUF,TEV_EVENT_ENTRY))
  515.             TEV_FIN;
  516.     }
  517.  
  518.     cc = pvmsbuf ? pvmsbuf->m_mid : 0;
  519.  
  520.     if (TEV_AMEXCL) {
  521.         if (TEV_DO_TRACE(TEV_GETSBUF,TEV_EVENT_EXIT)) {
  522.             TEV_PACK_INT( TEV_DID_MSB, TEV_DATA_SCALAR, &cc, 1, 1 );
  523.             TEV_FIN;
  524.         }
  525.         TEV_ENDEXCL;
  526.     }
  527.  
  528.     return cc;
  529. }
  530.  
  531.  
  532. int
  533. pvm_setrbuf(mid)
  534.     int mid;
  535. {
  536.     struct pmsg *mp = 0;
  537.     int cc = 0;
  538.     TEV_DECLS
  539.  
  540.     if (TEV_EXCLUSIVE) {
  541.         if (TEV_DO_TRACE(TEV_SETRBUF,TEV_EVENT_ENTRY)) {
  542.             TEV_PACK_INT( TEV_DID_MB, TEV_DATA_SCALAR, &mid, 1, 1 );
  543.             TEV_FIN;
  544.         }
  545.     }
  546.  
  547.     if (mid < 0) {
  548.         cc = PvmBadParam;
  549.     } else if (mid == 0) {
  550.         cc = pvmrbuf ? pvmrbuf->m_mid : 0;
  551.         pvmrbuf = 0;
  552.     } else if (mp = midtobuf(mid)) {
  553.         if (mp == pvmsbuf)
  554.             pvmsbuf = 0;
  555.         cc = pvmrbuf ? pvmrbuf->m_mid : 0;
  556.         pvmrbuf = mp;
  557.         (mp->m_codef->dec_init)(mp);
  558.     } else
  559.         cc = PvmNoSuchBuf;
  560.  
  561.     if (TEV_AMEXCL) {
  562.         if (TEV_DO_TRACE(TEV_SETRBUF,TEV_EVENT_EXIT)) {
  563.             TEV_PACK_INT( TEV_DID_MRB, TEV_DATA_SCALAR, &cc, 1, 1 );
  564.             TEV_FIN;
  565.         }
  566.         TEV_ENDEXCL;
  567.     }
  568.  
  569.     if (cc < 0)
  570.         lpvmerr("pvm_setrbuf", cc);
  571.     return cc;
  572. }
  573.  
  574.  
  575. int
  576. pvm_getrbuf()
  577. {
  578.     int cc;
  579.     TEV_DECLS
  580.  
  581.     if (TEV_EXCLUSIVE) {
  582.         if (TEV_DO_TRACE(TEV_GETRBUF,TEV_EVENT_ENTRY))
  583.             TEV_FIN;
  584.     }
  585.  
  586.     cc = pvmrbuf ? pvmrbuf->m_mid : 0;
  587.  
  588.     if (TEV_AMEXCL) {
  589.         if (TEV_DO_TRACE(TEV_GETRBUF,TEV_EVENT_EXIT)) {
  590.             TEV_PACK_INT( TEV_DID_MRB, TEV_DATA_SCALAR, &cc, 1, 1 );
  591.             TEV_FIN;
  592.         }
  593.         TEV_ENDEXCL;
  594.     }
  595.  
  596.     return cc;
  597. }
  598.  
  599.  
  600. int
  601. pvm_initsend(enc)
  602.     int enc;
  603. {
  604.     int cc;
  605.     TEV_DECLS
  606.  
  607.     if (TEV_EXCLUSIVE) {
  608.         if (TEV_DO_TRACE(TEV_INITSEND,TEV_EVENT_ENTRY)) {
  609.             TEV_PACK_INT( TEV_DID_ME, TEV_DATA_SCALAR, &enc, 1, 1 );
  610.             TEV_FIN;
  611.         }
  612.     }
  613.  
  614.     if ((cc = pvm_mkbuf(enc)) >= 0) {
  615.         if (pvmsbuf)
  616.             pvm_freebuf(pvmsbuf->m_mid);
  617.         pvm_setsbuf(cc);
  618.     }
  619.  
  620.     if (TEV_AMEXCL) {
  621.         if (TEV_DO_TRACE(TEV_INITSEND,TEV_EVENT_EXIT)) {
  622.             TEV_PACK_INT( TEV_DID_MSB, TEV_DATA_SCALAR, &cc, 1, 1 );
  623.             TEV_FIN;
  624.         }
  625.         TEV_ENDEXCL;
  626.     }
  627.  
  628.     if (cc < 0)
  629.         lpvmerr("pvm_initsend", cc);
  630.     return cc;
  631. }
  632.  
  633.  
  634. int
  635. pvm_bufinfo(mid, len, code, tid)
  636.     int mid;
  637.     int *len;
  638.     int *code;
  639.     int *tid;
  640. {
  641.     struct pmsg *mp;
  642.     int cc;
  643.     TEV_DECLS
  644.  
  645.     if (TEV_EXCLUSIVE) {
  646.         if (TEV_DO_TRACE(TEV_BUFINFO,TEV_EVENT_ENTRY)) {
  647.             TEV_PACK_INT( TEV_DID_MB, TEV_DATA_SCALAR, &mid, 1, 1 );
  648.             TEV_FIN;
  649.         }
  650.     }
  651.  
  652.     if (mid <= 0)
  653.         cc = PvmBadParam;
  654.     else
  655.         if (mp = midtobuf(mid)) {
  656.             cc = PvmOk;
  657.             if (len) {
  658.                 if (mp->m_flag & MM_PACK)
  659.                     pmsg_setlen(mp);
  660.                 *len = mp->m_len;
  661.             }
  662.             if (code)
  663.                 *code = mp->m_tag;
  664.             if (tid)
  665.                 *tid = mp->m_src;
  666.         } else
  667.             cc = PvmNoSuchBuf;
  668.  
  669.     if (TEV_AMEXCL) {
  670.         if (TEV_DO_TRACE(TEV_BUFINFO,TEV_EVENT_EXIT)) {
  671.             int ln, tg, sc;
  672.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  673.             if (!cc) {
  674.                 ln = mp->m_len;
  675.                 tg = mp->m_tag;
  676.                 sc = mp->m_src;
  677.             }
  678.             else
  679.                 ln = tg = sc = cc;
  680.             TEV_PACK_INT( TEV_DID_INB, TEV_DATA_SCALAR, &ln, 1, 1 );
  681.             TEV_PACK_INT( TEV_DID_IMC, TEV_DATA_SCALAR, &tg, 1, 1 );
  682.             TEV_PACK_INT( TEV_DID_IST, TEV_DATA_SCALAR, &sc, 1, 1 );
  683.             TEV_FIN;
  684.         }
  685.         TEV_ENDEXCL;
  686.     }
  687.  
  688.     if (cc < 0)
  689.         lpvmerr("pvm_bufinfo", cc);
  690.     return cc;
  691. }
  692.  
  693.  
  694. int
  695. pvm_pkbyte(cp, cnt, std)
  696.     char *cp;
  697.     int cnt;
  698.     int std;
  699. {
  700.     int cc;
  701.     long ad;
  702.     TEV_DECLS
  703.  
  704.     if (TEV_EXCLUSIVE) {
  705.         if (TEV_DO_TRACE(TEV_PKBYTE,TEV_EVENT_ENTRY)) {
  706.             ad = (long)cp;
  707.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  708.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  709.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  710.             TEV_FIN;
  711.         }
  712.     }
  713.  
  714.     if (cnt < 0)
  715.         cc = PvmBadParam;
  716.     else if (!pvmsbuf)
  717.         cc = PvmNoBuf;
  718.     else
  719.         cc = (pvmsbuf->m_codef->enc_byte) (pvmsbuf, (void*)cp, cnt, std, 1);
  720.  
  721.     if (TEV_AMEXCL) {
  722.         if (TEV_DO_TRACE(TEV_PKBYTE,TEV_EVENT_EXIT)) {
  723.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  724.             TEV_FIN;
  725.         }
  726.         TEV_ENDEXCL;
  727.     }
  728.     return (cc < 0 ? lpvmerr("pvm_pkbyte", cc) : PvmOk);
  729. }
  730.  
  731.  
  732. int
  733. pvm_upkbyte(cp, cnt, std)
  734.     char *cp;
  735.     int cnt;
  736.     int std;
  737. {
  738.     int cc;
  739.     long ad;
  740.     TEV_DECLS
  741.  
  742.     if (TEV_EXCLUSIVE) {
  743.         if (TEV_DO_TRACE(TEV_UPKBYTE,TEV_EVENT_ENTRY)) {
  744.             ad = (long)cp;
  745.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  746.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  747.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  748.             TEV_FIN;
  749.         }
  750.     }
  751.  
  752.     if (cnt < 0)
  753.         cc = PvmBadParam;
  754.     else if (!pvmrbuf)
  755.         cc = PvmNoBuf;
  756.     else
  757.         cc = (pvmrbuf->m_codef->dec_byte) (pvmrbuf, (void*)cp, cnt, std, 1);
  758.  
  759.     if (TEV_AMEXCL) {
  760.         if (TEV_DO_TRACE(TEV_UPKBYTE,TEV_EVENT_EXIT)) {
  761.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  762.             TEV_FIN;
  763.         }
  764.         TEV_ENDEXCL;
  765.     }
  766.     return (cc < 0 ? lpvmerr("pvm_upkbyte", cc) : PvmOk);
  767. }
  768.  
  769.  
  770. int
  771. pvm_pkcplx(xp, cnt, std)
  772.     float *xp;
  773.     int cnt;
  774.     int std;
  775. {
  776.     int cc;
  777.     long ad;
  778.     TEV_DECLS
  779.  
  780.     if (TEV_EXCLUSIVE) {
  781.         if (TEV_DO_TRACE(TEV_PKCPLX,TEV_EVENT_ENTRY)) {
  782.             ad = (long)xp;
  783.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  784.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  785.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  786.             TEV_FIN;
  787.         }
  788.     }
  789.  
  790.     if (cnt < 0)
  791.         cc = PvmBadParam;
  792.     else if (!pvmsbuf)
  793.         cc = PvmNoBuf;
  794.     else
  795.         cc = (pvmsbuf->m_codef->enc_cplx)
  796.                 (pvmsbuf, (void*)xp, cnt, std, sizeof(float)*2);
  797.  
  798.     if (TEV_AMEXCL) {
  799.         if (TEV_DO_TRACE(TEV_PKCPLX,TEV_EVENT_EXIT)) {
  800.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  801.             TEV_FIN;
  802.         }
  803.         TEV_ENDEXCL;
  804.     }
  805.     return (cc < 0 ? lpvmerr("pvm_pkcplx", cc) : PvmOk);
  806. }
  807.  
  808.  
  809. int
  810. pvm_upkcplx(xp, cnt, std)
  811.     float *xp;
  812.     int cnt;
  813.     int std;
  814. {
  815.     int cc;
  816.     long ad;
  817.     TEV_DECLS
  818.  
  819.     if (TEV_EXCLUSIVE) {
  820.         if (TEV_DO_TRACE(TEV_UPKCPLX,TEV_EVENT_ENTRY)) {
  821.             ad = (long)xp;
  822.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  823.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  824.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  825.             TEV_FIN;
  826.         }
  827.     }
  828.  
  829.     if (cnt < 0)
  830.         cc = PvmBadParam;
  831.     else if (!pvmrbuf)
  832.         cc = PvmNoBuf;
  833.     else
  834.         cc = (pvmrbuf->m_codef->dec_cplx)
  835.                 (pvmrbuf, (void*)xp, cnt, std, sizeof(float)*2);
  836.  
  837.     if (TEV_AMEXCL) {
  838.         if (TEV_DO_TRACE(TEV_UPKCPLX,TEV_EVENT_EXIT)) {
  839.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  840.             TEV_FIN;
  841.         }
  842.         TEV_ENDEXCL;
  843.     }
  844.     return (cc < 0 ? lpvmerr("pvm_upkcplx", cc) : PvmOk);
  845. }
  846.  
  847.  
  848. int
  849. pvm_pkdcplx(zp, cnt, std)
  850.     double *zp;
  851.     int cnt;
  852.     int std;
  853. {
  854.     int cc;
  855.     long ad;
  856.     TEV_DECLS
  857.  
  858.     if (TEV_EXCLUSIVE) {
  859.         if (TEV_DO_TRACE(TEV_PKDCPLX,TEV_EVENT_ENTRY)) {
  860.             ad = (long)zp;
  861.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  862.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  863.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  864.             TEV_FIN;
  865.         }
  866.     }
  867.  
  868.     if (cnt < 0)
  869.         cc = PvmBadParam;
  870.     else if (!pvmsbuf)
  871.         cc = PvmNoBuf;
  872.     else
  873.         cc = (pvmsbuf->m_codef->enc_dcplx)
  874.                 (pvmsbuf, (void*)zp, cnt, std, sizeof(double)*2);
  875.  
  876.     if (TEV_AMEXCL) {
  877.         if (TEV_DO_TRACE(TEV_PKDCPLX,TEV_EVENT_EXIT)) {
  878.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  879.             TEV_FIN;
  880.         }
  881.         TEV_ENDEXCL;
  882.     }
  883.     return (cc < 0 ? lpvmerr("pvm_pkdcplx", cc) : PvmOk);
  884. }
  885.  
  886.  
  887. int
  888. pvm_upkdcplx(zp, cnt, std)
  889.     double *zp;
  890.     int cnt;
  891.     int std;
  892. {
  893.     int cc;
  894.     long ad;
  895.     TEV_DECLS
  896.  
  897.     if (TEV_EXCLUSIVE) {
  898.         if (TEV_DO_TRACE(TEV_UPKDCPLX,TEV_EVENT_ENTRY)) {
  899.             ad = (long)zp;
  900.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  901.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  902.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  903.             TEV_FIN;
  904.         }
  905.     }
  906.  
  907.     if (cnt < 0)
  908.         cc = PvmBadParam;
  909.     else if (!pvmrbuf)
  910.         cc = PvmNoBuf;
  911.     else
  912.         cc = (pvmrbuf->m_codef->dec_dcplx)
  913.                 (pvmrbuf, (void*)zp, cnt, std, sizeof(double)*2);
  914.  
  915.     if (TEV_AMEXCL) {
  916.         if (TEV_DO_TRACE(TEV_UPKDCPLX,TEV_EVENT_EXIT)) {
  917.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  918.             TEV_FIN;
  919.         }
  920.         TEV_ENDEXCL;
  921.     }
  922.     return (cc < 0 ? lpvmerr("pvm_upkdcplx", cc) : PvmOk);
  923. }
  924.  
  925.  
  926. int
  927. pvm_pkdouble(dp, cnt, std)
  928.     double *dp;
  929.     int cnt;
  930.     int std;
  931. {
  932.     int cc;
  933.     long ad;
  934.     TEV_DECLS
  935.  
  936.     if (TEV_EXCLUSIVE) {
  937.         if (TEV_DO_TRACE(TEV_PKDOUBLE,TEV_EVENT_ENTRY)) {
  938.             ad = (long)dp;
  939.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  940.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  941.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  942.             TEV_FIN;
  943.         }
  944.     }
  945.  
  946.     if (cnt < 0)
  947.         cc = PvmBadParam;
  948.     else if (!pvmsbuf)
  949.         cc = PvmNoBuf;
  950.     else
  951.         cc = (pvmsbuf->m_codef->enc_double)
  952.                 (pvmsbuf, (void*)dp, cnt, std, sizeof(double));
  953.  
  954.     if (TEV_AMEXCL) {
  955.         if (TEV_DO_TRACE(TEV_PKDOUBLE,TEV_EVENT_EXIT)) {
  956.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  957.             TEV_FIN;
  958.         }
  959.         TEV_ENDEXCL;
  960.     }
  961.     return (cc < 0 ? lpvmerr("pvm_pkdouble", cc) : PvmOk);
  962. }
  963.  
  964.  
  965. int
  966. pvm_upkdouble(dp, cnt, std)
  967.     double *dp;
  968.     int cnt;
  969.     int std;
  970. {
  971.     int cc;
  972.     long ad;
  973.     TEV_DECLS
  974.  
  975.     if (TEV_EXCLUSIVE) {
  976.         if (TEV_DO_TRACE(TEV_UPKDOUBLE,TEV_EVENT_ENTRY)) {
  977.             ad = (long)dp;
  978.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  979.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  980.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  981.             TEV_FIN;
  982.         }
  983.     }
  984.  
  985.     if (cnt < 0)
  986.         cc = PvmBadParam;
  987.     else if (!pvmrbuf)
  988.         cc = PvmNoBuf;
  989.     else
  990.         cc = (pvmrbuf->m_codef->dec_double)
  991.                 (pvmrbuf, (void*)dp, cnt, std, sizeof(double));
  992.  
  993.     if (TEV_AMEXCL) {
  994.         if (TEV_DO_TRACE(TEV_UPKDOUBLE,TEV_EVENT_EXIT)) {
  995.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  996.             TEV_FIN;
  997.         }
  998.         TEV_ENDEXCL;
  999.     }
  1000.     return (cc < 0 ? lpvmerr("pvm_upkdouble", cc) : PvmOk);
  1001. }
  1002.  
  1003.  
  1004. int
  1005. pvm_pkfloat(fp, cnt, std)
  1006.     float *fp;
  1007.     int cnt;
  1008.     int std;
  1009. {
  1010.     int cc;
  1011.     long ad;
  1012.     TEV_DECLS
  1013.  
  1014.     if (TEV_EXCLUSIVE) {
  1015.         if (TEV_DO_TRACE(TEV_PKFLOAT,TEV_EVENT_ENTRY)) {
  1016.             ad = (long)fp;
  1017.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1018.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1019.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1020.             TEV_FIN;
  1021.         }
  1022.     }
  1023.  
  1024.     if (cnt < 0)
  1025.         cc = PvmBadParam;
  1026.     else if (!pvmsbuf)
  1027.         cc = PvmNoBuf;
  1028.     else
  1029.         cc = (pvmsbuf->m_codef->enc_float)
  1030.                 (pvmsbuf, (void*)fp, cnt, std, sizeof(float));
  1031.  
  1032.     if (TEV_AMEXCL) {
  1033.         if (TEV_DO_TRACE(TEV_PKFLOAT,TEV_EVENT_EXIT)) {
  1034.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1035.             TEV_FIN;
  1036.         }
  1037.         TEV_ENDEXCL;
  1038.     }
  1039.     return (cc < 0 ? lpvmerr("pvm_pkfloat", cc) : PvmOk);
  1040. }
  1041.  
  1042.  
  1043. int
  1044. pvm_upkfloat(fp, cnt, std)
  1045.     float *fp;
  1046.     int cnt;
  1047.     int std;
  1048. {
  1049.     int cc;
  1050.     long ad;
  1051.     TEV_DECLS
  1052.  
  1053.     if (TEV_EXCLUSIVE) {
  1054.         if (TEV_DO_TRACE(TEV_UPKFLOAT,TEV_EVENT_ENTRY)) {
  1055.             ad = (long)fp;
  1056.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1057.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1058.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1059.             TEV_FIN;
  1060.         }
  1061.     }
  1062.  
  1063.     if (cnt < 0)
  1064.         cc = PvmBadParam;
  1065.     else if (!pvmrbuf)
  1066.         cc = PvmNoBuf;
  1067.     else
  1068.         cc = (pvmrbuf->m_codef->dec_float)
  1069.                 (pvmrbuf, (void*)fp, cnt, std, sizeof(float));
  1070.  
  1071.     if (TEV_AMEXCL) {
  1072.         if (TEV_DO_TRACE(TEV_UPKFLOAT,TEV_EVENT_EXIT)) {
  1073.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1074.             TEV_FIN;
  1075.         }
  1076.         TEV_ENDEXCL;
  1077.     }
  1078.     return (cc < 0 ? lpvmerr("pvm_upkfloat", cc) : PvmOk);
  1079. }
  1080.  
  1081.  
  1082. int
  1083. pvm_pkint(np, cnt, std)
  1084.     int *np;
  1085.     int cnt;
  1086.     int std;
  1087. {
  1088.     int cc;
  1089.     long ad;
  1090.     TEV_DECLS
  1091.  
  1092.     if (TEV_EXCLUSIVE) {
  1093.         if (TEV_DO_TRACE(TEV_PKINT,TEV_EVENT_ENTRY)) {
  1094.             ad = (long)np;
  1095.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1096.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1097.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1098.             TEV_FIN;
  1099.         }
  1100.     }
  1101.  
  1102.     if (cnt < 0)
  1103.         cc = PvmBadParam;
  1104.     else if (!pvmsbuf)
  1105.         cc = PvmNoBuf;
  1106.     else
  1107.         cc = (pvmsbuf->m_codef->enc_int) (pvmsbuf, (void*)np, cnt, std, sizeof(int));
  1108.  
  1109.     if (TEV_AMEXCL) {
  1110.         if (TEV_DO_TRACE(TEV_PKINT,TEV_EVENT_EXIT)) {
  1111.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1112.             TEV_FIN;
  1113.         }
  1114.         TEV_ENDEXCL;
  1115.     }
  1116.     return (cc < 0 ? lpvmerr("pvm_pkint", cc) : PvmOk);
  1117. }
  1118.  
  1119.  
  1120. int
  1121. pvm_pkuint(np, cnt, std)
  1122.     unsigned int *np;
  1123.     int cnt;
  1124.     int std;
  1125. {
  1126.     int cc;
  1127.     long ad;
  1128.     TEV_DECLS
  1129.  
  1130.     if (TEV_EXCLUSIVE) {
  1131.         if (TEV_DO_TRACE(TEV_PKUINT,TEV_EVENT_ENTRY)) {
  1132.             ad = (long)np;
  1133.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1134.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1135.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1136.             TEV_FIN;
  1137.         }
  1138.     }
  1139.  
  1140.     if (cnt < 0)
  1141.         cc = PvmBadParam;
  1142.     else if (!pvmsbuf)
  1143.         cc = PvmNoBuf;
  1144.     else
  1145.         cc = (pvmsbuf->m_codef->enc_uint) (pvmsbuf, (void*)np, cnt, std, sizeof(int));
  1146.  
  1147.     if (TEV_AMEXCL) {
  1148.         if (TEV_DO_TRACE(TEV_PKUINT,TEV_EVENT_EXIT)) {
  1149.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1150.             TEV_FIN;
  1151.         }
  1152.         TEV_ENDEXCL;
  1153.     }
  1154.     return (cc < 0 ? lpvmerr("pvm_pkuint", cc) : PvmOk);
  1155. }
  1156.  
  1157.  
  1158. int
  1159. pvm_upkint(np, cnt, std)
  1160.     int *np;
  1161.     int cnt;
  1162.     int std;
  1163. {
  1164.     int cc;
  1165.     long ad;
  1166.     TEV_DECLS
  1167.  
  1168.     if (TEV_EXCLUSIVE) {
  1169.         if (TEV_DO_TRACE(TEV_UPKINT,TEV_EVENT_ENTRY)) {
  1170.             ad = (long)np;
  1171.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1172.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1173.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1174.             TEV_FIN;
  1175.         }
  1176.     }
  1177.  
  1178.     if (cnt < 0)
  1179.         cc = PvmBadParam;
  1180.     else if (!pvmrbuf)
  1181.         cc = PvmNoBuf;
  1182.     else
  1183.         cc = (pvmrbuf->m_codef->dec_int) (pvmrbuf, (void*)np, cnt, std, sizeof(int));
  1184.  
  1185.     if (TEV_AMEXCL) {
  1186.         if (TEV_DO_TRACE(TEV_UPKINT,TEV_EVENT_EXIT)) {
  1187.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1188.             TEV_FIN;
  1189.         }
  1190.         TEV_ENDEXCL;
  1191.     }
  1192.     return (cc < 0 ? lpvmerr("pvm_upkint", cc) : PvmOk);
  1193. }
  1194.  
  1195.  
  1196. int
  1197. pvm_upkuint(np, cnt, std)
  1198.     unsigned int *np;
  1199.     int cnt;
  1200.     int std;
  1201. {
  1202.     int cc;
  1203.     long ad;
  1204.     TEV_DECLS
  1205.  
  1206.     if (TEV_EXCLUSIVE) {
  1207.         if (TEV_DO_TRACE(TEV_UPKUINT,TEV_EVENT_ENTRY)) {
  1208.             ad = (long)np;
  1209.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1210.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1211.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1212.             TEV_FIN;
  1213.         }
  1214.     }
  1215.  
  1216.     if (cnt < 0)
  1217.         cc = PvmBadParam;
  1218.     else if (!pvmrbuf)
  1219.         cc = PvmNoBuf;
  1220.     else
  1221.         cc = (pvmrbuf->m_codef->dec_uint) (pvmrbuf, (void*)np, cnt, std, sizeof(int));
  1222.  
  1223.     if (TEV_AMEXCL) {
  1224.         if (TEV_DO_TRACE(TEV_UPKUINT,TEV_EVENT_EXIT)) {
  1225.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1226.             TEV_FIN;
  1227.         }
  1228.         TEV_ENDEXCL;
  1229.     }
  1230.     return (cc < 0 ? lpvmerr("pvm_upkuint", cc) : PvmOk);
  1231. }
  1232.  
  1233.  
  1234. int
  1235. pvm_pklong(np, cnt, std)
  1236.     long *np;
  1237.     int cnt;
  1238.     int std;
  1239. {
  1240.     int cc;
  1241.     long ad;
  1242.     TEV_DECLS
  1243.  
  1244.     if (TEV_EXCLUSIVE) {
  1245.         if (TEV_DO_TRACE(TEV_PKLONG,TEV_EVENT_ENTRY)) {
  1246.             ad = (long)np;
  1247.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1248.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1249.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1250.             TEV_FIN;
  1251.         }
  1252.     }
  1253.  
  1254.     if (cnt < 0)
  1255.         cc = PvmBadParam;
  1256.     else if (!pvmsbuf)
  1257.         cc = PvmNoBuf;
  1258.     else
  1259.         cc = (pvmsbuf->m_codef->enc_long) (pvmsbuf, (void*)np, cnt, std, sizeof(long));
  1260.  
  1261.     if (TEV_AMEXCL) {
  1262.         if (TEV_DO_TRACE(TEV_PKLONG,TEV_EVENT_EXIT)) {
  1263.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1264.             TEV_FIN;
  1265.         }
  1266.         TEV_ENDEXCL;
  1267.     }
  1268.     return (cc < 0 ? lpvmerr("pvm_pklong", cc) : PvmOk);
  1269. }
  1270.  
  1271.  
  1272. int
  1273. pvm_pkulong(np, cnt, std)
  1274.     unsigned long *np;
  1275.     int cnt;
  1276.     int std;
  1277. {
  1278.     int cc;
  1279.     long ad;
  1280.     TEV_DECLS
  1281.  
  1282.     if (TEV_EXCLUSIVE) {
  1283.         if (TEV_DO_TRACE(TEV_PKULONG,TEV_EVENT_ENTRY)) {
  1284.             ad = (long)np;
  1285.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1286.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1287.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1288.             TEV_FIN;
  1289.         }
  1290.     }
  1291.  
  1292.     if (cnt < 0)
  1293.         cc = PvmBadParam;
  1294.     else if (!pvmsbuf)
  1295.         cc = PvmNoBuf;
  1296.     else
  1297.         cc = (pvmsbuf->m_codef->enc_ulong) (pvmsbuf, (void*)np, cnt, std, sizeof(long));
  1298.  
  1299.     if (TEV_AMEXCL) {
  1300.         if (TEV_DO_TRACE(TEV_PKULONG,TEV_EVENT_EXIT)) {
  1301.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1302.             TEV_FIN;
  1303.         }
  1304.         TEV_ENDEXCL;
  1305.     }
  1306.     return (cc < 0 ? lpvmerr("pvm_pkulong", cc) : PvmOk);
  1307. }
  1308.  
  1309.  
  1310. int
  1311. pvm_upklong(np, cnt, std)
  1312.     long *np;
  1313.     int cnt;
  1314.     int std;
  1315. {
  1316.     int cc;
  1317.     long ad;
  1318.     TEV_DECLS
  1319.  
  1320.     if (TEV_EXCLUSIVE) {
  1321.         if (TEV_DO_TRACE(TEV_UPKLONG,TEV_EVENT_ENTRY)) {
  1322.             ad = (long)np;
  1323.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1324.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1325.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1326.             TEV_FIN;
  1327.         }
  1328.     }
  1329.  
  1330.     if (cnt < 0)
  1331.         cc = PvmBadParam;
  1332.     else if (!pvmrbuf)
  1333.         cc = PvmNoBuf;
  1334.     else
  1335.         cc = (pvmrbuf->m_codef->dec_long) (pvmrbuf, (void*)np, cnt, std, sizeof(long));
  1336.  
  1337.     if (TEV_AMEXCL) {
  1338.         if (TEV_DO_TRACE(TEV_UPKLONG,TEV_EVENT_EXIT)) {
  1339.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1340.             TEV_FIN;
  1341.         }
  1342.         TEV_ENDEXCL;
  1343.     }
  1344.     return (cc < 0 ? lpvmerr("pvm_upklong", cc) : PvmOk);
  1345. }
  1346.  
  1347.  
  1348. int
  1349. pvm_upkulong(np, cnt, std)
  1350.     unsigned long *np;
  1351.     int cnt;
  1352.     int std;
  1353. {
  1354.     int cc;
  1355.     long ad;
  1356.     TEV_DECLS
  1357.  
  1358.     if (TEV_EXCLUSIVE) {
  1359.         if (TEV_DO_TRACE(TEV_UPKULONG,TEV_EVENT_ENTRY)) {
  1360.             ad = (long)np;
  1361.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1362.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1363.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1364.             TEV_FIN;
  1365.         }
  1366.     }
  1367.  
  1368.     if (cnt < 0)
  1369.         cc = PvmBadParam;
  1370.     else if (!pvmrbuf)
  1371.         cc = PvmNoBuf;
  1372.     else
  1373.         cc = (pvmrbuf->m_codef->dec_ulong) (pvmrbuf, (void*)np, cnt, std, sizeof(long));
  1374.  
  1375.     if (TEV_AMEXCL) {
  1376.         if (TEV_DO_TRACE(TEV_UPKULONG,TEV_EVENT_EXIT)) {
  1377.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1378.             TEV_FIN;
  1379.         }
  1380.         TEV_ENDEXCL;
  1381.     }
  1382.     return (cc < 0 ? lpvmerr("pvm_upkulong", cc) : PvmOk);
  1383. }
  1384.  
  1385.  
  1386. int
  1387. pvm_pkshort(np, cnt, std)
  1388.     short *np;
  1389.     int cnt;
  1390.     int std;
  1391. {
  1392.     int cc;
  1393.     long ad;
  1394.     TEV_DECLS
  1395.  
  1396.     if (TEV_EXCLUSIVE) {
  1397.         if (TEV_DO_TRACE(TEV_PKSHORT,TEV_EVENT_ENTRY)) {
  1398.             ad = (long)np;
  1399.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1400.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1401.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1402.             TEV_FIN;
  1403.         }
  1404.     }
  1405.  
  1406.     if (cnt < 0)
  1407.         cc = PvmBadParam;
  1408.     else if (!pvmsbuf)
  1409.         cc = PvmNoBuf;
  1410.     else
  1411.         cc = (pvmsbuf->m_codef->enc_short) (pvmsbuf, (void*)np, cnt, std, sizeof(short));
  1412.  
  1413.     if (TEV_AMEXCL) {
  1414.         if (TEV_DO_TRACE(TEV_PKSHORT,TEV_EVENT_EXIT)) {
  1415.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1416.             TEV_FIN;
  1417.         }
  1418.         TEV_ENDEXCL;
  1419.     }
  1420.     return (cc < 0 ? lpvmerr("pvm_pkshort", cc) : PvmOk);
  1421. }
  1422.  
  1423.  
  1424. int
  1425. pvm_pkushort(np, cnt, std)
  1426.     unsigned short *np;
  1427.     int cnt;
  1428.     int std;
  1429. {
  1430.     int cc;
  1431.     long ad;
  1432.     TEV_DECLS
  1433.  
  1434.     if (TEV_EXCLUSIVE) {
  1435.         if (TEV_DO_TRACE(TEV_PKUSHORT,TEV_EVENT_ENTRY)) {
  1436.             ad = (long)np;
  1437.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1438.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1439.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1440.             TEV_FIN;
  1441.         }
  1442.     }
  1443.  
  1444.     if (cnt < 0)
  1445.         cc = PvmBadParam;
  1446.     else if (!pvmsbuf)
  1447.         cc = PvmNoBuf;
  1448.     else
  1449.         cc = (pvmsbuf->m_codef->enc_ushort) (pvmsbuf, (void*)np, cnt, std, sizeof(short));
  1450.  
  1451.     if (TEV_AMEXCL) {
  1452.         if (TEV_DO_TRACE(TEV_PKUSHORT,TEV_EVENT_EXIT)) {
  1453.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1454.             TEV_FIN;
  1455.         }
  1456.         TEV_ENDEXCL;
  1457.     }
  1458.     return (cc < 0 ? lpvmerr("pvm_pkushort", cc) : PvmOk);
  1459. }
  1460.  
  1461.  
  1462. int
  1463. pvm_upkshort(np, cnt, std)
  1464.     short *np;
  1465.     int cnt;
  1466.     int std;
  1467. {
  1468.     int cc;
  1469.     long ad;
  1470.     TEV_DECLS
  1471.  
  1472.     if (TEV_EXCLUSIVE) {
  1473.         if (TEV_DO_TRACE(TEV_UPKSHORT,TEV_EVENT_ENTRY)) {
  1474.             ad = (long)np;
  1475.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1476.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1477.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1478.             TEV_FIN;
  1479.         }
  1480.     }
  1481.  
  1482.     if (cnt < 0)
  1483.         cc = PvmBadParam;
  1484.     else if (!pvmrbuf)
  1485.         cc = PvmNoBuf;
  1486.     else
  1487.         cc = (pvmrbuf->m_codef->dec_short) (pvmrbuf, (void*)np, cnt, std, sizeof(short));
  1488.  
  1489.     if (TEV_AMEXCL) {
  1490.         if (TEV_DO_TRACE(TEV_UPKSHORT,TEV_EVENT_EXIT)) {
  1491.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1492.             TEV_FIN;
  1493.         }
  1494.         TEV_ENDEXCL;
  1495.     }
  1496.     return (cc < 0 ? lpvmerr("pvm_upkshort", cc) : PvmOk);
  1497. }
  1498.  
  1499.  
  1500. int
  1501. pvm_upkushort(np, cnt, std)
  1502.     unsigned short *np;
  1503.     int cnt;
  1504.     int std;
  1505. {
  1506.     int cc;
  1507.     long ad;
  1508.     TEV_DECLS
  1509.  
  1510.     if (TEV_EXCLUSIVE) {
  1511.         if (TEV_DO_TRACE(TEV_UPKUSHORT,TEV_EVENT_ENTRY)) {
  1512.             ad = (long)np;
  1513.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1514.             TEV_PACK_INT( TEV_DID_PC, TEV_DATA_SCALAR, &cnt, 1, 1 );
  1515.             TEV_PACK_INT( TEV_DID_PSD, TEV_DATA_SCALAR, &std, 1, 1 );
  1516.             TEV_FIN;
  1517.         }
  1518.     }
  1519.  
  1520.     if (cnt < 0)
  1521.         cc = PvmBadParam;
  1522.     else if (!pvmrbuf)
  1523.         cc = PvmNoBuf;
  1524.     else
  1525.         cc = (pvmrbuf->m_codef->dec_ushort) (pvmrbuf, (void*)np, cnt, std, sizeof(short));
  1526.  
  1527.     if (TEV_AMEXCL) {
  1528.         if (TEV_DO_TRACE(TEV_UPKUSHORT,TEV_EVENT_EXIT)) {
  1529.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1530.             TEV_FIN;
  1531.         }
  1532.         TEV_ENDEXCL;
  1533.     }
  1534.     return (cc < 0 ? lpvmerr("pvm_upkushort", cc) : PvmOk);
  1535. }
  1536.  
  1537.  
  1538. int
  1539. pvm_pkstr(cp)
  1540.     char *cp;
  1541. {
  1542.     int l = strlen(cp) + 1;
  1543.     int cc;
  1544.     long ad;
  1545.     TEV_DECLS
  1546.  
  1547.     if (TEV_EXCLUSIVE) {
  1548.         if (TEV_DO_TRACE(TEV_PKSTR,TEV_EVENT_ENTRY)) {
  1549.             ad = (long)cp;
  1550.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1551.             TEV_FIN;
  1552.         }
  1553.     }
  1554.  
  1555.     if (!pvmsbuf)
  1556.         cc = PvmNoBuf;
  1557.     else {
  1558.         /* can't do InPlace without a lot of grief */
  1559.         if (pvmsbuf->m_enc == 0x20000000)
  1560.             cc = PvmNotImpl;
  1561.         /* user defined, don't pack len, don't pack '\0' */
  1562.         else if (pvmsbuf->m_enc == 0x40000000)
  1563.             cc = (pvmsbuf->m_codef->enc_byte)
  1564.                 (pvmsbuf, (void*)cp, l - 1, 1, 1);
  1565.         else
  1566.             if (!(cc = (pvmsbuf->m_codef->enc_int)
  1567.                     (pvmsbuf, (void*)&l, 1, 1, sizeof(int))))
  1568.                 cc = (pvmsbuf->m_codef->enc_byte)
  1569.                         (pvmsbuf, (void*)cp, l, 1, 1);
  1570.     }
  1571.  
  1572.     if (TEV_AMEXCL) {
  1573.         if (TEV_DO_TRACE(TEV_PKSTR,TEV_EVENT_EXIT)) {
  1574.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1575.             TEV_FIN;
  1576.         }
  1577.         TEV_ENDEXCL;
  1578.     }
  1579.     return (cc < 0 ? lpvmerr("pvm_pkstr", cc) : PvmOk);
  1580. }
  1581.  
  1582.  
  1583. int
  1584. pvm_upkstr(cp)
  1585.     char *cp;
  1586. {
  1587.     int l;
  1588.     int cc;
  1589.     long ad;
  1590.     TEV_DECLS
  1591.  
  1592.     if (TEV_EXCLUSIVE) {
  1593.         if (TEV_DO_TRACE(TEV_UPKSTR,TEV_EVENT_ENTRY)) {
  1594.             ad = (long)cp;
  1595.             TEV_PACK_LONG( TEV_DID_PDA, TEV_DATA_SCALAR, &ad, 1, 1 );
  1596.             TEV_FIN;
  1597.         }
  1598.     }
  1599.  
  1600.     if (!pvmrbuf)
  1601.         cc = PvmNoBuf;
  1602.     else {
  1603.         if (!(cc = (pvmrbuf->m_codef->dec_int)
  1604.                 (pvmrbuf, (void*)&l, 1, 1, sizeof(int))))
  1605.             cc = (pvmrbuf->m_codef->dec_byte)
  1606.                     (pvmrbuf, (void*)cp, l, 1, 1);
  1607.     }
  1608.  
  1609.     if (TEV_AMEXCL) {
  1610.         if (TEV_DO_TRACE(TEV_UPKSTR,TEV_EVENT_EXIT)) {
  1611.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1612.             TEV_FIN;
  1613.         }
  1614.         TEV_ENDEXCL;
  1615.     }
  1616.     return (cc < 0 ? lpvmerr("pvm_upkstr", cc) : PvmOk);
  1617. }
  1618.  
  1619.  
  1620. /*    pvmupkstralloc()  (from pvmdpack.c upkstralloc(), spanked slightly)
  1621. *
  1622. *    Unpack a string from current message.  Result is null-terminated,
  1623. *    and in dynamic space..
  1624. *    Returns 0 if ok.
  1625. */
  1626.  
  1627. int
  1628. pvmupkstralloc(ss)
  1629.     char **ss;                /* return pointer */
  1630. {
  1631.     int cc;
  1632.     int l;
  1633.  
  1634.     if (!pvmrbuf)
  1635.         cc = PvmNoBuf;
  1636.     else {
  1637.         if (!(cc = (pvmrbuf->m_codef->dec_int)
  1638.                 (pvmrbuf, (void*)&l, 1, 1, sizeof(int)))) {
  1639.             *ss = TALLOC(l, char, "pustr");
  1640.             if ((cc = (pvmrbuf->m_codef->dec_byte)
  1641.                     (pvmrbuf, (void*)*ss, l, 1, 1)) < 0) {
  1642.                 PVM_FREE(*ss);
  1643.                 *ss = 0;
  1644.             }
  1645.         }
  1646.     }
  1647.     return cc;
  1648. }
  1649.  
  1650.  
  1651. int
  1652. pvm_vpackf(fmt, ap)
  1653.     char *fmt;
  1654.     va_list ap;
  1655. {
  1656.     char *p = fmt;
  1657.     int cc;
  1658.     int cnt, std;            /* count and stride of element */
  1659.     int vh, vl, vu;            /* short, long, unsigned variety */
  1660.     int isv;                /* param is a value not address */
  1661.     struct encvec *codef;
  1662.     char tc, *cp;            /* each type and a pointer */
  1663.     short th, *hp;
  1664.     int tn, *np;
  1665.     long tl, *lp;
  1666.     float tf, *fp;
  1667.     double td, *dp;
  1668.     TEV_DECLS
  1669.  
  1670.     if (TEV_EXCLUSIVE) {
  1671.         if (TEV_DO_TRACE(TEV_PACKF,TEV_EVENT_ENTRY)) {
  1672.             TEV_PACK_STRING( TEV_DID_PF, TEV_DATA_SCALAR, fmt, 1, 1 );
  1673.             TEV_FIN;
  1674.         }
  1675.     }
  1676.  
  1677.     if (p[0] == '%' && p[1] == '+') {
  1678.         cc = va_arg(ap, int);
  1679.         if ((cc = pvm_initsend(cc)) < 0)
  1680.             goto hork;
  1681.         p += 2;
  1682.     }
  1683.  
  1684.     if (!pvmsbuf) {
  1685.         cc = PvmNoBuf;
  1686.         goto hork;
  1687.     }
  1688.  
  1689.     codef = pvmsbuf->m_codef;
  1690.  
  1691.     while (*p) {
  1692.         if (*p++ == '%') {
  1693.             cnt = 1;
  1694.             std = 1;
  1695.             isv = 1;
  1696.             vl = vh = vu = 0;
  1697.             if (*p == '*') {
  1698.                 cnt = va_arg(ap, int);
  1699.                 isv = 0;
  1700.                 p++;
  1701.             } else
  1702.                 if (isdigit(*p)) {
  1703.                     cnt = atoi(p);
  1704.                     isv = 0;
  1705.                     while (isdigit(*++p)) ;
  1706.                 }
  1707.             if (*p == '.') {
  1708.                 isv = 0;
  1709.                 if (*++p == '*') {
  1710.                     std = va_arg(ap, int);
  1711.                     p++;
  1712.                 } else
  1713.                     if (isdigit(*p)) {
  1714.                         std = atoi(p);
  1715.                         while (isdigit(*++p)) ;
  1716.                     }
  1717.             }
  1718.             for (cc = 1; cc; ) {
  1719.                 switch (*p++) {
  1720.  
  1721.                 case 'h':
  1722.                     vh = 1;
  1723.                     break;
  1724.  
  1725.                 case 'l':
  1726.                     vl = 1;
  1727.                     break;
  1728.  
  1729.                 case 'u':
  1730.                     vu = 1;
  1731.                     break;
  1732.  
  1733.                 default:
  1734.                     p--;
  1735.                     cc = 0;
  1736.                 }
  1737.             }
  1738.  
  1739.             switch (*p++) {
  1740.  
  1741.             case 'c':
  1742.                 if (isv) {
  1743.                     tc = va_arg(ap, char);
  1744.                     cp = &tc;
  1745.                 } else
  1746.                     cp = va_arg(ap, char *);
  1747.                 cc = (codef->enc_byte) (pvmsbuf, (void*)cp, cnt, std, 1);
  1748. #ifdef    DEBUGPACKF
  1749.                 printf("%d %d %s%schar\n", cnt, std, (vu ? "unsigned " : ""),
  1750.                         (isv ? "" : "&"));
  1751. #endif
  1752.                 break;
  1753.  
  1754.             case 'd':
  1755.                 if (vl) {
  1756.                     if (isv) {
  1757.                         tl = va_arg(ap, long);
  1758.                         lp = &tl;
  1759.                     } else
  1760.                         lp = va_arg(ap, long *);
  1761.                     cc = (codef->enc_long)
  1762.                             (pvmsbuf, (void*)lp, cnt, std, sizeof(long));
  1763.                 } else
  1764.                     if (vh) {
  1765.                         if (isv) {
  1766.                             th = va_arg(ap, short);
  1767.                             hp = &th;
  1768.                         } else
  1769.                             hp = va_arg(ap, short *);
  1770.                         cc = (codef->enc_short)
  1771.                                 (pvmsbuf, (void*)hp, cnt, std, sizeof(short));
  1772.                     } else {
  1773.                         if (isv) {
  1774.                             tn = va_arg(ap, int);
  1775.                             np = &tn;
  1776.                         } else
  1777.                             np = va_arg(ap, int *);
  1778.                         cc = (codef->enc_int)
  1779.                                 (pvmsbuf, (void*)np, cnt, std, sizeof(int));
  1780.                     }
  1781. #ifdef    DEBUGPACKF
  1782.                 printf("%d %d %s%s%s%sint\n", cnt, std,
  1783.                         (vu ? "unsigned " : ""),
  1784.                         (vl ? "long " : ""),
  1785.                         (vh ? "short " : ""),
  1786.                         (isv ? "" : "&"));
  1787. #endif
  1788.                 break;
  1789.  
  1790.             case 'f':
  1791.                 if (vl) {
  1792.                     if (isv) {
  1793.                         td = va_arg(ap, double);
  1794.                         dp = &td;
  1795.                     } else
  1796.                         dp = va_arg(ap, double *);
  1797.                     cc = (codef->enc_double)
  1798.                             (pvmsbuf, (void*)dp, cnt, std, sizeof(double));
  1799.                 } else {
  1800.                     if (isv) {
  1801. /*
  1802.                         tf = va_arg(ap, float);
  1803. */
  1804.                         td = va_arg(ap, double);
  1805.                         tf = td;
  1806.                         fp = &tf;
  1807.                     } else
  1808.                         fp = va_arg(ap, float *);
  1809.                     cc = (codef->enc_float)
  1810.                             (pvmsbuf, (void*)fp, cnt, std, sizeof(float));
  1811.                 }
  1812. #ifdef    DEBUGPACKF
  1813.                 printf("%d %d %s%s\n", cnt, std, (isv ? "" : "&"),
  1814.                         (vl ? "double" : "float"));
  1815. #endif
  1816.                 break;
  1817.  
  1818.             case 'x':
  1819.                 if (vl) {
  1820.                     dp = va_arg(ap, double *);
  1821.                     cc = (codef->enc_dcplx)
  1822.                             (pvmsbuf, (void*)dp, cnt, std, sizeof(double)*2);
  1823.                 } else {
  1824.                     fp = va_arg(ap, float *);
  1825.                     cc = (codef->enc_cplx)
  1826.                             (pvmsbuf, (void*)fp, cnt, std, sizeof(float)*2);
  1827.                 }
  1828. #ifdef    DEBUGPACKF
  1829.                 printf("%d %d %s&cplx\n", cnt, std, (vl ? "double " : ""));
  1830. #endif
  1831.                 break;
  1832.  
  1833.             case 's':
  1834.                 if (pvmsbuf->m_enc == 2)    /* oops, can't do this */
  1835.                     cc = PvmNotImpl;
  1836.                 else {
  1837.                     cp = va_arg(ap, char *);
  1838.                     cnt = strlen(cp) + 1;
  1839.                     if (!(cc = (codef->enc_int) (pvmsbuf, (void*)&cnt, 1, 1, sizeof(int))))
  1840.                         cc = (codef->enc_byte) (pvmsbuf, (void*)cp, cnt, 1, 1);
  1841. #ifdef    DEBUGPACKF
  1842.                     printf("string\n");
  1843. #endif
  1844.                 }
  1845.                 break;
  1846.  
  1847.             default:
  1848.                 cc = PvmBadParam;
  1849.                 break;
  1850.             }
  1851.  
  1852.             if (cc)
  1853.                 goto hork;
  1854.         }
  1855. /*
  1856.         else
  1857.             printf("'%c'\n", *(p - 1));
  1858. */
  1859.     }
  1860.     cc = PvmOk;
  1861.  
  1862. hork:
  1863.     if (TEV_AMEXCL) {
  1864.         if (TEV_DO_TRACE(TEV_PACKF,TEV_EVENT_EXIT)) {
  1865.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  1866.             TEV_FIN;
  1867.         }
  1868.         TEV_ENDEXCL;
  1869.     }
  1870.  
  1871.     if (cc < 0)
  1872.         lpvmerr("pvm_packf", cc);
  1873.     return cc;
  1874. }
  1875.  
  1876.  
  1877. int
  1878. #ifdef __STDC__
  1879. pvm_packf(const char *fmt, ...)
  1880. #else
  1881. pvm_packf(va_alist)
  1882.     va_dcl
  1883. #endif
  1884. {
  1885.     va_list ap;
  1886.     int cc;
  1887.  
  1888. #ifdef __STDC__
  1889.     va_start(ap, fmt);
  1890. #else
  1891.     char    *fmt;
  1892.  
  1893.     va_start(ap);
  1894.     fmt = va_arg(ap, char *);
  1895. #endif
  1896.  
  1897.     cc = pvm_vpackf(fmt, ap);
  1898.     va_end(ap);
  1899.  
  1900.     return cc;
  1901. }
  1902.  
  1903.  
  1904. int
  1905. pvm_vunpackf(fmt, ap)
  1906.     char *fmt;
  1907.     va_list ap;
  1908. {
  1909.     char *p = fmt;
  1910.     int cc;
  1911.     int cnt, std;        /* count and stride of element */
  1912.     int vh, vl, vu;        /* short, long, unsigned variety */
  1913.     struct encvec *codef;
  1914.     char *cp;            /* pointers for each type */
  1915.     short *hp;
  1916.     int *np;
  1917.     long *lp;
  1918.     float *fp;
  1919.     double *dp;
  1920.     TEV_DECLS
  1921.  
  1922.     if (TEV_EXCLUSIVE) {
  1923.         if (TEV_DO_TRACE(TEV_UNPACKF,TEV_EVENT_ENTRY)) {
  1924.             TEV_PACK_STRING( TEV_DID_PF, TEV_DATA_SCALAR, fmt, 1, 1 );
  1925.             TEV_FIN;
  1926.         }
  1927.     }
  1928.  
  1929.     if (!pvmrbuf) {
  1930.         cc = PvmNoBuf;
  1931.         goto hork;
  1932.     }
  1933.  
  1934.     codef = pvmrbuf->m_codef;
  1935.  
  1936.     while (*p) {
  1937.         if (*p++ == '%') {
  1938.             cnt = 1;
  1939.             std = 1;
  1940.             vl = vh = vu = 0;
  1941.             if (*p == '*') {
  1942.                 cnt = va_arg(ap, int);
  1943.                 p++;
  1944.             } else
  1945.                 if (isdigit(*p)) {
  1946.                     cnt = atoi(p);
  1947.                     while (isdigit(*++p)) ;
  1948.                 }
  1949.             if (*p == '.') {
  1950.                 if (*++p == '*') {
  1951.                     std = va_arg(ap, int);
  1952.                     p++;
  1953.                 } else
  1954.                     if (isdigit(*p)) {
  1955.                         std = atoi(p);
  1956.                         while (isdigit(*++p)) ;
  1957.                     }
  1958.             }
  1959.             for (cc = 1; cc; ) {
  1960.                 switch (*p++) {
  1961.  
  1962.                 case 'h':
  1963.                     vh = 1;
  1964.                     break;
  1965.  
  1966.                 case 'l':
  1967.                     vl = 1;
  1968.                     break;
  1969.  
  1970.                 case 'u':
  1971.                     vu = 1;
  1972.                     break;
  1973.  
  1974.                 default:
  1975.                     p--;
  1976.                     cc = 0;
  1977.                 }
  1978.             }
  1979.  
  1980.             switch (*p++) {
  1981.  
  1982.             case 'c':
  1983.                 cp = va_arg(ap, char *);
  1984.                 cc = (codef->dec_byte) (pvmrbuf, (void*)cp, cnt, std, 1);
  1985.                 break;
  1986.  
  1987.             case 'd':
  1988.                 if (vl) {
  1989.                     lp = va_arg(ap, long *);
  1990.                     cc = (vu ? codef->dec_ulong : codef->dec_long)
  1991.                             (pvmrbuf, (void*)lp, cnt, std, sizeof(long));
  1992.                 } else
  1993.                     if (vh) {
  1994.                         hp = va_arg(ap, short *);
  1995.                         cc = (vu ? codef->dec_ushort : codef->dec_short)
  1996.                                 (pvmrbuf, (void*)hp, cnt, std, sizeof(short));
  1997.                     } else {
  1998.                         np = va_arg(ap, int *);
  1999.                         cc = (vu ? codef->dec_uint : codef->dec_int)
  2000.                                 (pvmrbuf, (void*)np, cnt, std, sizeof(int));
  2001.                     }
  2002.                 break;
  2003.  
  2004.             case 'f':
  2005.                 if (vl) {
  2006.                     dp = va_arg(ap, double *);
  2007.                     cc = (codef->dec_double)
  2008.                             (pvmrbuf, (void*)dp, cnt, std, sizeof(double));
  2009.                 } else {
  2010.                     fp = va_arg(ap, float *);
  2011.                     cc = (codef->dec_float)
  2012.                             (pvmrbuf, (void*)fp, cnt, std, sizeof(float));
  2013.                 }
  2014.                 break;
  2015.  
  2016.             case 'x':
  2017.                 if (vl) {
  2018.                     dp = va_arg(ap, double *);
  2019.                     cc = (codef->dec_dcplx)
  2020.                             (pvmrbuf, (void*)dp, cnt, std, sizeof(double)*2);
  2021.                 } else {
  2022.                     fp = va_arg(ap, float *);
  2023.                     cc = (codef->dec_cplx)
  2024.                             (pvmrbuf, (void*)fp, cnt, std, sizeof(float)*2);
  2025.                 }
  2026.                 break;
  2027.  
  2028.             case 's':
  2029.                 cp = va_arg(ap, char *);
  2030.                 if (!(cc = (codef->dec_int) (pvmrbuf, (void*)&cnt, 1, 1, sizeof(int))))
  2031.                     cc = (codef->dec_byte) (pvmrbuf, (void*)cp, cnt, 1, 1);
  2032.                 break;
  2033.  
  2034.             default:
  2035.                 cc = PvmBadParam;
  2036.                 break;
  2037.             }
  2038.  
  2039.             if (cc)
  2040.                 goto hork;
  2041.         }
  2042.     }
  2043.     cc = PvmOk;
  2044.  
  2045. hork:
  2046.     if (TEV_AMEXCL) {
  2047.         if (TEV_DO_TRACE(TEV_UNPACKF,TEV_EVENT_EXIT)) {
  2048.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  2049.             TEV_FIN;
  2050.         }
  2051.         TEV_ENDEXCL;
  2052.     }
  2053.  
  2054.     if (cc < 0)
  2055.         lpvmerr("pvm_unpackf", cc);
  2056.     return cc;
  2057. }
  2058.  
  2059.  
  2060. int
  2061. #ifdef __STDC__
  2062. pvm_unpackf(const char *fmt, ...)
  2063. #else
  2064. pvm_unpackf(va_alist)
  2065.     va_dcl
  2066. #endif
  2067. {
  2068.     va_list ap;
  2069.     int cc;
  2070.  
  2071. #ifdef __STDC__
  2072.     va_start(ap, fmt);
  2073. #else
  2074.     char    *fmt;
  2075.  
  2076.     va_start(ap);
  2077.     fmt = va_arg(ap, char *);
  2078. #endif
  2079.  
  2080.     cc = pvm_vunpackf(fmt, ap);
  2081.     va_end(ap);
  2082.  
  2083.     return cc;
  2084. }
  2085.  
  2086.  
  2087. int
  2088. pvm_getminfo(mid, info)
  2089.     int mid;
  2090.     struct pvmminfo *info;
  2091. {
  2092.     struct pmsg *mp;
  2093.     int cc;
  2094.     TEV_DECLS
  2095.  
  2096.     if (TEV_EXCLUSIVE) {
  2097.         if (TEV_DO_TRACE(TEV_GETMINFO,TEV_EVENT_ENTRY)) {
  2098.             TEV_PACK_INT( TEV_DID_MB, TEV_DATA_SCALAR, &mid, 1, 1 );
  2099.             TEV_FIN;
  2100.         }
  2101.     }
  2102.  
  2103.     if (mid <= 0)
  2104.         cc = PvmBadParam;
  2105.     else if (mp = midtobuf(mid)) {
  2106.         if (mp->m_flag & MM_PACK)
  2107.             pmsg_setlen(mp);
  2108.         info->len = mp->m_len;
  2109.         info->ctx = mp->m_ctx;
  2110.         info->tag = mp->m_tag;
  2111.         info->wid = mp->m_wid;
  2112.         info->enc = mp->m_enc;
  2113.         info->crc = mp->m_crc;
  2114.         info->src = mp->m_src;
  2115.         info->dst = mp->m_dst;
  2116.         cc = PvmOk;
  2117.     } else
  2118.         cc = PvmNoSuchBuf;
  2119.  
  2120.     if (TEV_AMEXCL) {
  2121.         if (TEV_DO_TRACE(TEV_GETMINFO,TEV_EVENT_EXIT)) {
  2122.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  2123.             TEV_FIN;
  2124.         }
  2125.         TEV_ENDEXCL;
  2126.     }
  2127.  
  2128.     if (cc < 0)
  2129.         lpvmerr("pvm_getminfo", cc);
  2130.     return cc;
  2131. }
  2132.  
  2133.  
  2134. int
  2135. pvm_setminfo(mid, info)
  2136.     int mid;
  2137.     struct pvmminfo *info;
  2138. {
  2139.     struct pmsg *mp;
  2140.     int cc;
  2141.     TEV_DECLS
  2142.  
  2143.     if (TEV_EXCLUSIVE) {
  2144.         if (TEV_DO_TRACE(TEV_SETMINFO,TEV_EVENT_ENTRY)) {
  2145.             TEV_PACK_INT( TEV_DID_MB, TEV_DATA_SCALAR, &mid, 1, 1 );
  2146.             TEV_FIN;
  2147.         }
  2148.     }
  2149.  
  2150.     if (mid <= 0)
  2151.         cc = PvmBadParam;
  2152.     else if (mp = midtobuf(mid)) {
  2153.         mp->m_ctx = info->ctx;
  2154.         mp->m_tag = info->tag;
  2155.         mp->m_wid = info->wid;
  2156.         mp->m_src = info->src;
  2157.         mp->m_dst = info->dst;
  2158.         cc = PvmOk;
  2159.     } else
  2160.         cc = PvmNoSuchBuf;
  2161.  
  2162.     if (TEV_AMEXCL) {
  2163.         if (TEV_DO_TRACE(TEV_SETMINFO,TEV_EVENT_EXIT)) {
  2164.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  2165.             TEV_FIN;
  2166.         }
  2167.         TEV_ENDEXCL;
  2168.     }
  2169.  
  2170.     if (cc < 0)
  2171.         lpvmerr("pvm_setminfo", cc);
  2172.     return cc;
  2173. }
  2174.  
  2175.  
  2176. int
  2177. pvm_pkmesg(mid)
  2178.     int mid;
  2179. {
  2180.     int cc = 0;
  2181.     struct pmsg *mp;
  2182.  
  2183.     if (mid <= 0)
  2184.         cc = PvmBadParam;
  2185.     else if (mp = midtobuf(mid)) {
  2186.         if (!pvmsbuf)
  2187.             cc = PvmNoBuf;
  2188.         else if (mp == pvmsbuf)
  2189.             cc = PvmBadParam;
  2190.         else
  2191.             cc = pmsg_pack(pvmsbuf, mp);
  2192.     } else
  2193.         cc = PvmNoSuchBuf;
  2194.  
  2195.     return cc;
  2196. }
  2197.  
  2198.  
  2199. int
  2200. pvm_pkmesgbody(mid)
  2201.     int mid;
  2202. {
  2203.     int cc = 0;
  2204.     struct pmsg *mp;
  2205.  
  2206.     if (mid <= 0)
  2207.         cc = PvmBadParam;
  2208.     else if (mp = midtobuf(mid)) {
  2209.         if (!pvmsbuf)
  2210.             cc = PvmNoBuf;
  2211.         else if (mp == pvmsbuf)
  2212.             cc = PvmBadParam;
  2213.         else
  2214.             cc = pmsg_packbody(pvmsbuf, mp);
  2215.     } else
  2216.         cc = PvmNoSuchBuf;
  2217.  
  2218.     return cc;
  2219. }
  2220.  
  2221.  
  2222. int
  2223. pvm_upkmesg()
  2224. {
  2225.     int cc = 0;
  2226.     struct pmsg *mp;
  2227.  
  2228.     if (!pvmrbuf)
  2229.         cc = PvmNoBuf;
  2230.     else {
  2231.         if (mp = umbuf_new()) {
  2232.             if (!(cc = pmsg_unpack(pvmrbuf, mp)))
  2233.                 cc = mp->m_mid;
  2234.         } else
  2235.             cc = PvmNoMem;
  2236.     }
  2237.     return cc;
  2238. }
  2239.  
  2240.  
  2241. #ifdef    PVM33COMPAT
  2242. /***************************************************************
  2243.  **  Crusty functions that will fall off in the next version  **
  2244.  **                                                           **
  2245.  ***************************************************************/
  2246.  
  2247. /*
  2248. *    use pvm_getminfo for pvm_getmwid
  2249. *    use pvm_setminfo for pvm_setmwid
  2250. */
  2251.  
  2252. int
  2253. pvm_getmwid(mid)
  2254.     int mid;
  2255. {
  2256.     struct pmsg *mp = 0;
  2257.     int cc = 0;
  2258.     TEV_DECLS
  2259.  
  2260.     if (TEV_EXCLUSIVE) {
  2261.         if (TEV_DO_TRACE(TEV_GETMWID,TEV_EVENT_ENTRY)) {
  2262.             TEV_PACK_INT( TEV_DID_MB, TEV_DATA_SCALAR, &mid, 1, 1 );
  2263.             TEV_FIN;
  2264.         }
  2265.     }
  2266.  
  2267.     if (mid < 0)
  2268.         cc = PvmBadParam;
  2269.     else if (mp = midtobuf(mid))
  2270.         cc = mp->m_wid;
  2271.     else
  2272.         cc = PvmNoSuchBuf;
  2273.  
  2274.     if (TEV_AMEXCL) {
  2275.         if (TEV_DO_TRACE(TEV_GETMWID,TEV_EVENT_EXIT)) {
  2276.             TEV_PACK_INT( TEV_DID_WID, TEV_DATA_SCALAR, &cc, 1, 1 );
  2277.             TEV_FIN;
  2278.         }
  2279.         TEV_ENDEXCL;
  2280.     }
  2281.  
  2282.     if (cc < 0)
  2283.         lpvmerr("pvm_getmwid", cc);
  2284.     return cc;
  2285. }
  2286.  
  2287.  
  2288. int
  2289. pvm_setmwid(mid, wid)
  2290.     int mid;
  2291.     int wid;
  2292. {
  2293.     struct pmsg *mp = 0;
  2294.     int cc = 0;
  2295.     TEV_DECLS
  2296.  
  2297.     if (TEV_EXCLUSIVE) {
  2298.         if (TEV_DO_TRACE(TEV_SETMWID,TEV_EVENT_ENTRY)) {
  2299.             TEV_PACK_INT( TEV_DID_MB, TEV_DATA_SCALAR, &mid, 1, 1 );
  2300.             TEV_PACK_INT( TEV_DID_WID, TEV_DATA_SCALAR, &wid, 1, 1 );
  2301.             TEV_FIN;
  2302.         }
  2303.     }
  2304.  
  2305.     if (mid < 0)
  2306.         cc = PvmBadParam;
  2307.     else if (mp = midtobuf(mid))
  2308.         mp->m_wid = wid;
  2309.     else
  2310.         cc = PvmNoSuchBuf;
  2311.  
  2312.     if (TEV_AMEXCL) {
  2313.         if (TEV_DO_TRACE(TEV_SETMWID,TEV_EVENT_EXIT)) {
  2314.             TEV_PACK_INT( TEV_DID_CC, TEV_DATA_SCALAR, &cc, 1, 1 );
  2315.             TEV_FIN;
  2316.         }
  2317.         TEV_ENDEXCL;
  2318.     }
  2319.  
  2320.     if (cc < 0)
  2321.         lpvmerr("pvm_setmwid", cc);
  2322.     return cc;
  2323. }
  2324.  
  2325. #endif    /*PVM33COMPAT*/
  2326.  
  2327.